let myName:string="1111";

let nameiNFO="AAAY";


interface Person {
    name:string;
    age:number;
    greet():void;
}


class Student implements Person{

    constructor(public name:string,public age:number){}

    greet(): void {
        console.log("实际参数");
        
    }

}



enum Dirction {

}




abstract class Animal {
    abstract makeSound():void;
}



class Dog extends Animal {
    makeSound(){
        console.log("实现方法");
        
    }
}


/**
 * 泛型
 */


function identity<T>(value:T):T {
    return value;
}


let num=identity<number>(42);


// ts基本语法

const hello:string="hello";



// 类声明
class MyPerson {
    name:string;
    age:number;
  
    greet(){
        return "这是实际的参数！";
    }

   data(){
    return `${this.name}helloinfo`
   }
}

// 接口和类型别名

interface AnimalInfo {
    name:string;
    makeSound():void;
}


type  xid=string |number;

export class Person2{
    constructor() {}
}


// 泛型

function name2<T>(params:T):T {
    return params;
    
}


/**
 * Map对象
 * 可以传递键值对
 */

// 创建Map

let myMap=new Map([
    ["key1","value1"]
]);




/**
 * 元祖
 * 
 */

let mytuple:[number,string];
mytuple=[42,"sss"];


/**
 * 联合类型
 */


let letData:string|number;
letData=122;



interface IPerson{
    firstName:string;

    info():void;
    sayHi:()=>string;
}



class Car {

    disp<T>(i:T):T{
return i;
    }
}




/**
 * 对象
 * 
 */



let sites={
    site1:"a",
    site2:"b"
}

console.log(sites.site1);




/**
 * 
 * 泛型
 * 泛型的T是约定俗成的标识符，比如说T(Type) U，V等，实际上可以用任何标识符作为泛型
    T约定俗成，可以代表所有的数据类型
    K,V代表键和值的泛型数据类型
    E表示数组的泛型数据类型

    R表示返回值的泛型数据类型
    U,V 通常表示第二，第三泛型类型参数

    以上种种都是约定俗成，但是并不是强制规定

*/

// K，v 表示建(key) 和值(V)的泛型类型参数
interface KeyValuePair<K,V>{
key:K;
value:V;
}

function myKey<U>(params:U):U {
    return params;
    
}



/**
 * 命名空间
 */


namespace SomeNameSpaceName{
    export interface isSomefaceName{}
    export class isClassfaceName{}
}


// 读取到的方法，好像只能读取class类，不能读取接口，好像也是，接口直接读取没有实际意义？
SomeNameSpaceName.isClassfaceName;